﻿#define _CRT_SECURE_NO_WARNINGS 1
//给你一个字符串 s 和一个 长度相同 的整数数组 indices 。
//请你重新排列字符串 s ，其中第 i 个字符需要移动到 indices[i] 指示的位置。
//返回重新排列后的字符串。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/shuffle-string
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//char * restoreString(char * s, int* indices, int indicesSize){
//	char* a = (char*)malloc(indicesSize*sizeof(char) + 1);
//	int i = 0;
//	int j = 0;
//	for (i = 0; i<indicesSize; i++)
//	{
//		for (j = 0; j<indicesSize; j++)
//		{
//			if (indices[j] == i)
//			{
//				a[i] = s[j];
//				break;
//			}
//		}
//	}
//	a[indicesSize] = '\0';
//	return a;
//}








/**给你一个数组 arr ，请你将每个元素用它右边最大的元素替换，如果是最后一个元素，用 -1 替换。

完成所有替换操作后，请你返回这个数组。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* replaceElements(int* arr, int arrSize, int* returnSize){
//	int* a = (int*)malloc(arrSize*sizeof(int));
//	*returnSize = arrSize;
//	if (arrSize == 1 || arrSize == 0)
//	{
//		a[0] = -1;
//		return a;
//	}
//	int i = 0;
//	int j = 0;
//	int max = 0;
//	for (i = 0; i<arrSize - 1; i++)
//	{
//		max = -1;
//		for (j = i + 1; j<arrSize; j++)
//		{
//			if (arr[j]>max)
//			{
//				max = arr[j];
//			}
//		}
//		a[i] = max;
//	}
//	i = arrSize - 1;
//	a[i] = -1;
//	return a;
//}









//给你一个整数数组 arr ，以及 a、b 、c 三个整数。请你统计其中好三元组的数量。
//如果三元组(arr[i], arr[j], arr[k]) 满足下列全部条件，则认为它是一个 好三元组 。
//0 <= i < j < k < arr.length
//| arr[i] - arr[j] | <= a
//| arr[j] - arr[k] | <= b
//| arr[i] - arr[k] | <= c
//其中 | x | 表示 x 的绝对值。
//返回 好三元组的数量 。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/count-good-triplets
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int countGoodTriplets(int* arr, int arrSize, int a, int b, int c){
//	int i = 0;
//	int j = 0;
//	int k = 0;
//	int count = 0;
//	for (i = 0; i<arrSize - 2; i++)
//	{
//		for (j = i + 1; j<arrSize - 1; j++)
//		{
//			for (k = j + 1; k<arrSize; k++)
//			{
//				if (abs(arr[i] - arr[j]) <= a&&abs(arr[j] - arr[k]) <= b&&abs(arr[i] - arr[k]) <= c)
//				{
//					count++;
//				}
//			}
//		}
//	}
//	return count;
//}








//给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。
///**
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* countBits(int n, int* returnSize){
//	int i = 0;
//	int j = 0;
//	int* a = (int*)malloc((n + 1)*sizeof(int));
//	*returnSize = n + 1;
//	a[0] = 0;
//	for (i = 1; i <= n; i++)
//	{
//		a[i] = a[i >> 1] + (i & 1);
//	}
//	return a;
//}







//给你一个整数 n（10 进制）和一个基数 k ，请你将 n 从 10 进制表示转换为 k 进制表示，计算并返回转换后各位数字的 总和 。
//转换后，各位数字应当视作是 10 进制数字，且它们的总和也应当按 10 进制表示返回。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/sum-of-digits-in-base-k
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int sumBase(int n, int k){
//	int count = 0;
//	while (n)
//	{
//		count += n%k;
//		n /= k;
//	}
//	return count;
//}







/**给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/flipping-an-image
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
//int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){
//	int i = 0;
//	int j = 0;
//	int k = 0;
//	int tmp = 0;
//	for (i = 0; i<imageSize; i++)
//	{
//		for (j = *imageColSize - 1, k = 0; k <= j; k++, j--)
//		{
//			tmp = !image[i][j];
//			image[i][j] = !image[i][k];
//			image[i][k] = tmp;
//		}
//	}
//	*returnSize = imageSize;
//	*returnColumnSizes = imageColSize;
//	return image;
//}








//给你一个整数数组 nums （下标从 0 开始）。每一次操作中，你可以选择数组中一个元素，并将它增加 1 。
//比方说，如果 nums = [1, 2, 3] ，你可以选择增加 nums[1] 得到 nums = [1, 3, 3] 。
//请你返回使 nums 严格递增 的 最少 操作次数。
//我们称数组 nums 是 严格递增的 ，当它满足对于所有的 0 <= i < nums.length - 1 都有 nums[i] < nums[i + 1] 。一个长度为 1 的数组是严格递增的一种特殊情况。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/minimum-operations-to-make-the-array-increasing
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int minOperations(int* nums, int numsSize){
//	int i = 0;
//	int count = 0;
//	for (i = 0; i<numsSize - 1; i++)
//	{
//		while (nums[i] >= nums[i + 1])
//		{
//			nums[i + 1] += 1;
//			count++;
//		}
//	}
//	return count;
//}







//小扣在秋日市集发现了一款速算机器人。店家对机器人说出两个数字（记作 x 和 y），请小扣说出计算指令：
//"A" 运算：使 x = 2 * x + y；
//"B" 运算：使 y = 2 * y + x。
//在本次游戏中，店家说出的数字为 x = 1 和 y = 0，小扣说出的计算指令记作仅由大写字母 A、B 组成的字符串 s，字符串中字符的顺序表示计算顺序，请返回最终 x 与 y 的和为多少。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/nGK0Fy
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int calculate(char* s){
//	int x = 1;
//	int y = 0;
//	int i = 0;
//	int len = strlen(s);
//	for (i = 0; i<len; i++)
//	{
//		if (s[i] == 'A')
//		{
//			x = 2 * x + y;
//		}
//		if (s[i] == 'B')
//		{
//			y = 2 * y + x;
//		}
//	}
//	return x + y;
//}







//给你一个坐标 coordinates ，它是一个字符串，表示国际象棋棋盘中一个格子的坐标。下图是国际象棋棋盘示意图。
//bool squareIsWhite(char * coordinates){
//	if ((coordinates[1] % 2) != coordinates[0] % 2)
//	{
//		return true;
//	}
//	return false;
//}







//给你两个整数数组 startTime（开始时间）和 endTime（结束时间），并指定一个整数 queryTime 作为查询时间。
//已知，第 i 名学生在 startTime[i] 时开始写作业并于 endTime[i] 时完成作业。
//请返回在查询时间 queryTime 时正在做作业的学生人数。形式上，返回能够使 queryTime 处于区间[startTime[i], endTime[i]]（含）的学生人数
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/number-of-students-doing-homework-at-a-given-time
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int busyStudent(int* startTime, int startTimeSize, int* endTime, int endTimeSize, int queryTime){
//	int count = 0;
//	int i = 0;
//	for (i = 0; i<startTimeSize; i++)
//	{
//		if (startTime[i] <= queryTime&&endTime[i] >= queryTime)
//		{
//			count++;
//		}
//	}
//	return count;
//}